0.1 Survival Analysis in R

https://rviews.rstudio.com/2017/09/25/survival-analysis-with-r/

library(survival)
library(ranger)
library(ggplot2)
library(dplyr)


Attaching package: ‘dplyr’

The following objects are masked from ‘package:stats’:

    filter, lag

The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union

library(ggfortify)

data(veteran)
head(veteran)

0.1.1 Censored Data

km <- with(veteran, Surv(time, status))
head(km,80)

 [1]  72  411  228  126  118   10   82  110  314  100+  42    8  144   25+  11   30  384    4   54   13  123+  97+ 153   59  117   16  151   22   56   21   18 
[32] 139   20   31   52  287   18   51  122   27   54    7   63  392   10    8   92   35  117  132   12  162    3   95  177  162  216  553  278   12  260  200 
[63] 156  182+ 143  105  103  250  100  999  112   87+ 231+ 242  991  111    1  587  389   33

0.1.2 Kaplan Meier

km_fit <- survfit(Surv(time, status) ~ 1, data = veteran)
km_fit

Call: survfit(formula = Surv(time, status) ~ 1, data = veteran)

      n  events  median 0.95LCL 0.95UCL 
    137     128      80      52     105

0.1.3 Life Table

summary(km_fit, times = c(1,30,60,90*(1:10)))

Call: survfit(formula = Surv(time, status) ~ 1, data = veteran)

 time n.risk n.event survival std.err lower 95% CI upper 95% CI
    1    137       2    0.985  0.0102      0.96552       1.0000
   30     97      39    0.700  0.0392      0.62774       0.7816
   60     73      22    0.538  0.0427      0.46070       0.6288
   90     62      10    0.464  0.0428      0.38731       0.5560
  180     27      30    0.222  0.0369      0.16066       0.3079
  270     16       9    0.144  0.0319      0.09338       0.2223
  360     10       6    0.090  0.0265      0.05061       0.1602
  450      5       5    0.045  0.0194      0.01931       0.1049
  540      4       1    0.036  0.0175      0.01389       0.0934
  630      2       2    0.018  0.0126      0.00459       0.0707
  720      2       0    0.018  0.0126      0.00459       0.0707
  810      2       0    0.018  0.0126      0.00459       0.0707
  900      2       0    0.018  0.0126      0.00459       0.0707

0.1.4 KM Graph Overall

plot(km_fit, xlab="Days", main = 'Kaplan Meyer Plot') #base graphics is always ready

autoplot(km_fit)

0.1.5 KM per treatment group

km_trt_fit <- survfit(Surv(time, status) ~ trt, data = veteran)
km_trt_fit

Call: survfit(formula = Surv(time, status) ~ trt, data = veteran)

       n events median 0.95LCL 0.95UCL
trt=1 69     64  103.0      59     132
trt=2 68     64   52.5      44      95

0.1.6 KM Graph per treatment group

autoplot(km_trt_fit)

1 survminer

http://www.sthda.com/english/rpkgs/survminer/#uber-platinum-customized-survival-curves

2 OpenIntro Statistics

https://www.openintro.org/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R&referrer=/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R_code&referrer=/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R_code_df-cp&referrer=/stat/surv.php

install.packages("OIsurv")

Warning in install.packages :
  package ‘OIsurv’ is not available (for R version 3.5.1)

library(OIsurv)

Error in library(OIsurv) : there is no package called ‘OIsurv’

library(help=KMsurv)

my.surv.object

 [1]   1    3    3    4   10   13   13   16   16   24   26   27 
[13]  28   30   30   32   41   51   65   67   70   72   73   77 
[25]  91   93   96  100  104  157  167   61+  74+  79+  80+  81+
[37]  87+  87+  88+  89+  93+  97+ 101+ 104+ 108+ 109+ 120+ 131+
[49] 150+ 231+ 240+ 400+

my.surv.object

 [1] (51,52]  (58,59]  (55,57]  (28,50]  (21,51+] (19,47] 
 [7] (25,57]  (48,59]  (47,61]  (25,61+] (31,62+] (24,57+]
[13] (25,58+] (30,67+] (33,68+] (36,61]  (30,61+] (41,63] 
[19] (43,69]  (45,69]  (35,70+] (29,63+] (35,65+] (32,67] 
[25] (36,76]  (32,71+]

rm(list=ls())

#===> loading packages and such <===#
#install.packages("OIsurv")
library(OIsurv)
data(aids)
aids
attach(aids)
infect
detach(aids)
aids$infect

#===> survival object <===#
data(tongue); attach(tongue)   # the following will not affect computations
# create a subset for just the first group by using [type==1]
my.surv.object <- Surv(time[type==1], delta[type==1])
my.surv.object
detach(tongue)

data(psych); attach(psych)
my.surv.object <- Surv(age, age+time, death)
my.surv.object
detach(psych)

#===> K-M Estimate <===#
data(tongue); attach(tongue)
my.surv <- Surv(time[type==1], delta[type==1])
survfit(my.surv ~ 1)
my.fit <- survfit(my.surv ~ 1)
summary(my.fit)$surv     # returns the Kaplan-Meier estimate at each t_i
summary(my.fit)$time     # {t_i}
summary(my.fit)$n.risk   # {Y_i}
summary(my.fit)$n.event  # {d_i}
summary(my.fit)$std.err  # standard error of the K-M estimate at {t_i}
summary(my.fit)$lower    # lower pointwise estimates (alternatively, $upper)
str(my.fit)              # full summary of the my.fit object
str(summary(my.fit))     # full summary of the my.fit object
pdf("../figures/kmPlot.pdf", 7, 4.5)
plot(my.fit, main="Kaplan-Meier estimate with 95% confidence bounds",
   xlab="time", ylab="survival function")
dev.off()
my.fit1 <- survfit( Surv(time, delta) ~ type )   # here the key is "type"
detach(tongue)

#===> confidence bands <===#
data(bmt); attach(bmt)
my.surv <- Surv(t2[group==1], d3[group==1])
my.cb <- confBands(my.surv, confLevel=0.95, type="hall")
pdf("../figures/confBand.pdf", 8, 5)
plot(survfit(my.surv ~ 1), xlim=c(100, 600), xlab="time",
  ylab="Estimated Survival Function",
  main="Reproducing Confidence Bands for Example 4.2 in Klein/Moeschberger")

lines(my.cb$time, my.cb$lower, lty=3, type="s")
lines(my.cb$time, my.cb$upper, lty=3, type="s")
legend(100, 0.3, legend=c("K-M survival estimate",
  "pointwise intervals","confidence bands"), lty=1:3)
dev.off()
detach(bmt)


#===> cumulative hazard <===#
data(tongue); attach(tongue)
my.surv <- Surv(time[type==1], delta[type==1])
my.fit  <- summary(survfit(my.surv ~ 1))
H.hat   <- -log(my.fit$surv)
H.hat   <- c(H.hat, tail(H.hat, 1))
h.sort.of <- my.fit$n.event / my.fit$n.risk
H.tilde   <- cumsum(h.sort.of)
H.tilde   <- c(H.tilde, tail(H.tilde, 1))
pdf("../figures/cumHazard.pdf", 6, 4)
plot(c(my.fit$time, 250), H.hat, xlab="time", ylab="cumulative hazard",
  main="comparing cumulative hazards", ylim=range(c(H.hat, H.tilde)), type="s")
points(c(my.fit$time, 250), H.tilde, lty=2, type="s")
legend("topleft", legend=c("H.hat","H.tilde"), lty=1:2)
dev.off()
detach(tongue)


#===> mean/median <===#
data(drug6mp); attach(drug6mp)
my.surv <- Surv(t1, rep(1, 21))   # all placebo patients observed
survfit(my.surv ~ 1)
print(survfit(my.surv ~ 1), print.rmean=TRUE)
detach(drug6mp)

#===> test for 2+ samples <===#
data(btrial); attach(btrial)
survdiff(Surv(time, death) ~ im)   # output omitted
survdiff(Surv(time, death) ~ im, rho=1)   # output omitted
detach(btrial)

#===> coxph, time-independent <===#
data(burn); attach(burn)
my.surv   <- Surv(T1, D1)
coxph.fit <- coxph(my.surv ~ Z1 + as.factor(Z11), method="breslow")
coxph.fit
co <- coxph.fit$coefficients  # may use coxph.fit$coeff instead
va <- coxph.fit$var           # I^(-1), estimated cov matrix of the estimates
ll <- coxph.fit$loglik        # log-likelihood for alt and null MLEs, resp.
my.survfit.object <- survfit(coxph.fit)
hold <- survfit(my.surv ~ 1)
#source("http://www.stat.ucla.edu/~david/teac/surv/local-coxph-test.R")
coxph.fit
C   <- matrix(c(0, 1, 0, 0,
                0, 0, 1, 0,
                0, 0, 0, 1), nrow=3, byrow=TRUE)
d   <- rep(0, 3)
t1  <- C %*% co - d
t2  <- C %*% va %*% t(C)
XW2 <- c(t(t1) %*% solve(t2) %*% t1)
pchisq(XW2, 3, lower.tail=FALSE)
#local.coxph.test(coxph.fit, 2:4)
my.survfit.object <- survfit(coxph.fit)
detach(burn)


#===> coxph, time-dependent <===#
data(relapse)
relapse

N  <- dim(relapse)[1]
t1 <- rep(0, N+sum(!is.na(relapse$int)))  # initialize start time at 0
t2 <- rep(-1, length(t1))                 # build vector for end times
d  <- rep(-1, length(t1))                 # whether event was censored
g  <- rep(-1, length(t1))                 # gender covariate
i  <- rep(FALSE, length(t1))              # initialize intervention at FALSE

j  <- 1
for(ii in 1:dim(relapse)[1]){
  if(is.na(relapse$int[ii])){      # no intervention, copy survival record
    t2[j] <- relapse$event[ii]
    d[j]  <- relapse$delta[ii]
    g[j]  <- relapse$gender[ii]
    j <- j+1
  } else {                         # intervention, split records
    g[j+0:1] <- relapse$gender[ii] # gender is same for each time
    d[j]     <- 0                  # no relapse observed pre-intervention
    d[j+1]   <- relapse$delta[ii]  # relapse occur post-intervention?
    i[j+1]   <- TRUE               # intervention covariate, post-intervention
    t2[j]    <- relapse$int[ii]-1  # end of pre-intervention
    t1[j+1]  <- relapse$int[ii]-1  # start of post-intervention
    t2[j+1]  <- relapse$event[ii]  # end of post-intervention
    j <- j+2                       # two records added
  }
}

mySurv <- Surv(t1, t2, d)        # pg 3 discusses left-trunc. right-cens. data
myCPH  <- coxph(mySurv ~ g + i)

#data(burn); attach(burn)
##source("http://www.stat.ucla.edu/~david/teac/surv/time-dep-coxph.R")
#td.coxph <- timeDepCoxph(burn, "T1", "D1", 2:4, "Z1", verbose=FALSE)
#td.coxph   # some model output is omitted for brevity
#detach(burn)

#===> AFT models <===#
data(larynx)
attach(larynx)
srFit <- survreg(Surv(time, delta) ~ as.factor(stage) + age, dist="weibull")
summary(srFit)
srFitExp <- survreg(Surv(time, delta) ~ as.factor(stage) + age, dist="exponential")
summary(srFitExp)
srFitExp$coeff    # covariate coefficients
srFitExp$icoef    # intercept and scale coefficients
srFitExp$var      # variance-covariance matrix
srFitExp$loglik   # log-likelihood
srFit$scale       # not using srFitExp (defaulted to 1)
detach(larynx)


# Posted with permission of the code author:
# Beau Benjamin Bruce
# Author email: bbbruce@emory.edu
# 
# This code is available under GPL-2
# For license information, see
# http://cran.r-project.org/web/licenses/GPL-2

library(KMsurv)
data(burn)

#=====> Convert a data frame to a counting process version <=====#
#=====> Allows for time dependent variables to be introduced <=====#
df.cp = function(data,t.var,status.var,covars=setdiff(names(data),c(t.var,status.var))) {
  # data: data frame that represents the dataset
  # t.var: the column name of "data" that represents the survival time variable
  # status.var: the column name of "data" that represents the status variable
  # covars: list other covariates to retain
  
  # Returned object: a data frame that breaks each event down to a counting process
  
  # sorted times, append to 0
  t.sort <- c(0,sort(unlist(unique(data[t.var]))))
  
  # for each data point find times less than or equal to the obs' time
  t.list <- lapply(unlist(data[t.var]),function(x) t.sort[t.sort<=x])
  
  # create a list of datasets with covariates and all relevant start/stop times
  # use with to set the environment to the correct list item
  df.list <- lapply(seq_along(t.list),function(i) cbind(with(list(x=t.list[[i]]),
                     # start by removing one from end of x, stop by removing first of x
                     # include the status variable in the dataframe - helpful later                                        
                     data.frame(start=head(x,-1),stop=tail(x,-1),data[i,c(status.var,covars)]))))

  # do.call uses df.list as the argument for rbind
  df <- do.call(rbind,df.list)

  # create the correct status need last time for each
  # subject with status=1 to to be status=1 but all others status=0
  #
  # the lapply creates vectors 0,0,0,...,1 based on length of t.list
  # need to substract 2 because the lag takes one away, then need one for the 1 at end
  # do.call with c binds them together into a single vector
  # this is then multiplied by status to correct it
  keep.status <- do.call(c,lapply(t.list,function(x) c(rep(0,length(x)-2),1)))
  df[status.var] <- df[status.var] * keep.status
  df
}


#=====> Create the counting process data frame <=====#
burn.cp <- df.cp(burn,'T1','D1')
burn.cp <- within(burn.cp,{ T1Z1 <- log(stop)*Z1; }) 

#=====> Apply the Cox Proportional Hazards model <=====#
coxph(Surv(start,stop,D1) ~ Z1+Z2+Z3+T1Z1,data=burn.cp)

3 survsup

Plotting survival curves with the survsup package

https://cran.r-project.org/web/packages/survsup/vignettes/survsup_intro.html

http://github.com/dlindholm/survsup/

# install.packages("survsup")

library(survsup)
library(ggplot2)
library(survival)
library(dplyr)

fit <- survfit(Surv(time, status) ~ 1, data = lung)
plot_survfit(fit)

lung %>%
  survfit(Surv(time, status) ~ 1, data = .) %>%
  plot_survfit()

lung %>%
  survfit(Surv(time, status) ~ 1, data = .) %>%
  plot_survfit(cuminc = FALSE)

lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE)

lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE, ci = TRUE)

lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE, ci = TRUE) + # <--- NOTE!
  labs(x = "Time (days)", y = "Survival (%)")

lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE) %>%
  nar()

lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE) %>%
  nar(size = 3)

colon %>%
  survfit(Surv(time, status) ~ rx, data = .) %>%
  plot_survfit() %>%
  nar() +
  scale_color_manual(values = c("darkorange", "steelblue", "darkred"))

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  skislopes()

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  skislopes(reverse = TRUE)

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  cat4()

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  hcl_rainbow()

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  hcl_rainbow(reverse = TRUE)

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(lwd = 2)

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(lwd = 0.5)

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(legend.title = "Extent of disease")

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(ylim = c(0, 100)) %>%
  nar()

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(xmax = 2000) %>%
  nar()

colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(xmax = 2000, xbreaks = c(0, 1000, 2000)) %>%
  nar()

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar()

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(flip = TRUE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(size = 5, flip = TRUE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(size = 2, flip = TRUE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(y_offset = 0.1, flip = TRUE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(y_offset = 0.03, flip = TRUE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(separator = FALSE)

colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(sep_color = "grey90", sep_lwd = 1.5)

https://cran.r-project.org/package=gridExtra

library(gridExtra)

p <- list(
  p1 = colon %>%
    survfit(Surv(time, status) ~ sex, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar() +
    labs(tag = "A"),

  p2 = colon %>%
    survfit(Surv(time, status) ~ node4, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar() +
    labs(tag = "B")
)

grid.arrange(grobs = p, ncol = 2)

# Store plots in a list
p <- list(
  p1 = colon %>%
    survfit(Surv(time, status) ~ 1, data = .) %>%
    plot_survfit(ylim = c(0, 100)) +
    labs(tag = "A"),

  p2 = colon %>%
    survfit(Surv(time, status) ~ rx, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "B"),

  p3 = colon %>%
    survfit(Surv(time, status) ~ extent, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "C"),

  p4 = colon %>%
    survfit(Surv(time, status) ~ sex, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "D"),

  p5 = colon %>%
    survfit(Surv(time, status) ~ node4, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "E"),

  p6 = colon %>%
    survfit(Surv(time, status) ~ surg, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "F")

)

#Define layout matrix
lay <- rbind(c(1,1,2),
             c(1,1,3),
             c(4,5,6))

#Plot it all!
grid.arrange(grobs = p, layout_matrix = lay)

4 survivalAnalysis

4.1 Univariate Survival Analysis

https://cran.r-project.org/web/packages/survivalAnalysis/vignettes/univariate.html

---
title: "My R Codes For Data Analysis"
subtitle: "Survival Analysis"
author: "[Serdar Balcı, MD, Pathologist](https://www.serdarbalci.com/)"
date: '`r format(Sys.Date())`'
output: 
  html_notebook: 
    fig_caption: yes
    highlight: tango
    number_sections: yes
    theme: paper
    toc: yes
    toc_depth: 5
    toc_float: yes
  html_document: 
    code_folding: hide
    df_print: kable
    keep_md: yes
    number_sections: yes
    theme: cerulean
    toc: yes
    toc_float: yes
    highlight: kate
---

## Survival Analysis in R


https://rviews.rstudio.com/2017/09/25/survival-analysis-with-r/


```{r}
library(survival)
library(ranger)
library(ggplot2)
library(dplyr)
library(ggfortify)
```


```{r}
data(veteran)
head(veteran)
```

### Censored Data

```{r}
km <- with(veteran, Surv(time, status))

head(km,80)

```


### Kaplan Meier 

```{r}
km_fit <- survfit(Surv(time, status) ~ 1, data = veteran)

km_fit
```


### Life Table

```{r}
summary(km_fit, times = c(1,30,60,90*(1:10)))

```

### KM Graph Overall

```{r}
plot(km_fit, xlab="Days", main = 'Kaplan Meyer Plot') #base graphics is always ready

```


```{r}
autoplot(km_fit)

```


### KM per treatment group


```{r}
km_trt_fit <- survfit(Surv(time, status) ~ trt, data = veteran)
km_trt_fit

```


### KM Graph per treatment group


```{r}
autoplot(km_trt_fit)
```




# survminer

http://www.sthda.com/english/rpkgs/survminer/#uber-platinum-customized-survival-curves





<!-- vet <- mutate(veteran, AG = ifelse((age < 60), "LT60", "OV60"), -->
<!--               AG = factor(AG), -->
<!--               trt = factor(trt,labels=c("standard","test")), -->
<!--               prior = factor(prior,labels=c("N0","Yes"))) -->

<!-- km_AG_fit <- survfit(Surv(time, status) ~ AG, data = vet) -->
<!-- km_AG_fit -->

<!-- autoplot(km_AG_fit) -->


<!-- Fit Cox Model -->
<!-- cox <- coxph(Surv(time, status) ~ trt + celltype + karno + diagtime + age + prior , data = vet) -->
<!-- cox -->
<!-- summary(cox) -->

<!-- cox_fit <- survfit(cox) -->
<!-- cox_fit -->
<!-- plot(cox_fit, main = "cph model", xlab="Days") -->
<!-- autoplot(cox_fit) -->

<!-- aa_fit <-aareg(Surv(time, status) ~ trt + celltype + -->
<!--                    karno + diagtime + age + prior ,  -->
<!--                data = vet) -->
<!-- aa_fit -->


<!-- #summary(aa_fit)  # provides a more complete summary of results -->
<!-- autoplot(aa_fit) -->


<!-- # ranger model -->
<!-- r_fit <- ranger(Surv(time, status) ~ trt + celltype +  -->
<!--                     karno + diagtime + age + prior, -->
<!--                 data = vet, -->
<!--                 mtry = 4, -->
<!--                 importance = "permutation", -->
<!--                 splitrule = "extratrees", -->
<!--                 verbose = TRUE) -->


<!-- # Average the survival models -->
<!-- death_times <- r_fit$unique.death.times  -->
<!-- surv_prob <- data.frame(r_fit$survival) -->
<!-- avg_prob <- sapply(surv_prob,mean) -->

<!-- # Plot the survival models for each patient -->
<!-- plot(r_fit$unique.death.times,r_fit$survival[1,],  -->
<!--      type = "l",  -->
<!--      ylim = c(0,1), -->
<!--      col = "red", -->
<!--      xlab = "Days", -->
<!--      ylab = "survival", -->
<!--      main = "Patient Survival Curves") -->

<!-- # -->
<!-- cols <- colors() -->
<!-- for (n in sample(c(2:dim(vet)[1]), 20)){ -->
<!--     lines(r_fit$unique.death.times, r_fit$survival[n,], type = "l", col = cols[n]) -->
<!-- } -->
<!-- lines(death_times, avg_prob, lwd = 2) -->
<!-- legend(500, 0.7, legend = c('Average = black')) -->


<!-- vi <- data.frame(sort(round(r_fit$variable.importance, 4), decreasing = TRUE)) -->
<!-- names(vi) <- "importance" -->
<!-- head(vi) -->


<!-- cat("Prediction Error = 1 - Harrell's c-index = ", r_fit$prediction.error) -->


<!-- # Set up for ggplot -->
<!-- kmi <- rep("KM",length(km_fit$time)) -->
<!-- km_df <- data.frame(km_fit$time,km_fit$surv,kmi) -->
<!-- names(km_df) <- c("Time","Surv","Model") -->

<!-- coxi <- rep("Cox",length(cox_fit$time)) -->
<!-- cox_df <- data.frame(cox_fit$time,cox_fit$surv,coxi) -->
<!-- names(cox_df) <- c("Time","Surv","Model") -->

<!-- rfi <- rep("RF",length(r_fit$unique.death.times)) -->
<!-- rf_df <- data.frame(r_fit$unique.death.times,avg_prob,rfi) -->
<!-- names(rf_df) <- c("Time","Surv","Model") -->

<!-- plot_df <- rbind(km_df,cox_df,rf_df) -->

<!-- p <- ggplot(plot_df, aes(x = Time, y = Surv, color = Model)) -->
<!-- p + geom_line() -->




<!-- ############ -->





<!-- install.packages("OIsurv") -->
<!-- library(OIsurv) -->

<!-- library(help=KMsurv) -->

<!-- data(aids) -->
<!-- glimpse(aids) -->


<!-- data(tongue) -->

<!-- glimpse(tongue) -->

<!-- my.surv.object <- Surv(tongue$time[tongue$type==1], tongue$delta[tongue$type==1]) -->

<!-- my.surv.object -->

<!-- data(psych) -->

<!-- my.surv.object2 <- Surv(psych$age, psych$age+psych$time, psych$death) -->

<!-- my.surv.object2 -->



<!-- ```{r} -->
<!-- library("survival") -->
<!-- fit <- survfit(Surv(time,status) -->
<!-- ~ sex, data = lung) -->
<!-- class(fit) -->
<!-- ## [1] "survfit" -->
<!-- library("survminer") -->
<!-- ggsurvplot(fit, data = lung) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- ggsurvplot(fit, data = lung, fun = "event") -->

<!-- ``` -->


<!-- ```{r} -->
<!-- ggsurvplot(fit, data = lung, fun = "cumhaz") -->
<!-- ``` -->

<!-- ```{r} -->
<!-- ggsurvplot(fit, data = lung, -->
<!-- conf.int = TRUE, -->
<!-- pval = TRUE, -->
<!-- fun = "pct", -->
<!-- risk.table = TRUE, -->
<!-- tables.height = 0.3, -->
<!-- size = 0.8, -->
<!-- linetype = "strata", -->
<!-- palette = c("#E7B800", -->
<!-- "#2E9FDF"), -->
<!-- legend = "top", -->
<!-- legend.title = "Sex", -->
<!-- legend.labs = c("Male", -->
<!-- "Female"), -->
<!-- cex = 0.2 -->
<!-- ) -->
<!-- ``` -->

<!-- ```{r} -->
<!-- library("survival") -->
<!-- fit <- coxph(Surv(time, status) ~ sex + age, data = lung) -->
<!-- ftest <- cox.zph(fit) -->
<!-- ftest -->
<!-- ``` -->

<!-- ```{r} -->
<!-- library("survminer") -->
<!-- ggcoxzph(ftest) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- library("survival") -->
<!-- library("survminer") -->
<!-- fit <- coxph(Surv(time, status) ~ -->
<!-- sex + age, data = lung) -->

<!-- ``` -->




<!-- ```{r} -->
<!-- ggcoxdiagnostics(fit, -->
<!-- type = "deviance", -->
<!-- ox.scale = "linear.predictions") -->

<!-- ``` -->



<!-- ```{r} -->
<!-- ggcoxdiagnostics(fit, -->
<!-- type = "schoenfeld", -->
<!-- ox.scale = "time") -->
<!-- ``` -->




<!-- # Analysis -->

<!-- ## Survival Analysis -->

<!-- https://github.com/datacamp/tutorial -->

<!-- Based on https://www.datacamp.com/community/tutorials/survival-analysis-R -->


<!-- ```{r} -->
<!-- library(tutorial) -->
<!-- library(survival) -->
<!-- library(survminer) -->
<!-- library(tidyverse) -->
<!-- library(jmv) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- data(ovarian) -->
<!-- glimpse(ovarian) -->
<!-- help(ovarian) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- summary(ovarian) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- varOvarian <- names(ovarian) -->

<!-- ovarian2 <- ovarian %>%  -->
<!--     map_df(as.factor) -->

<!-- jmv::descriptives(ovarian, varOvarian, freq = TRUE) -->

<!-- jmv::descriptives(ovarian2, varOvarian, freq = TRUE) -->

<!-- ``` -->


<!-- ```{r} -->
<!-- # Dichotomize age and change data labels -->
<!-- ovarian$rx <- factor(ovarian$rx,  -->
<!--                      levels = c("1", "2"),  -->
<!--                      labels = c("A", "B")) -->
<!-- ovarian$resid.ds <- factor(ovarian$resid.ds,  -->
<!--                            levels = c("1", "2"),  -->
<!--                            labels = c("no", "yes")) -->
<!-- ovarian$ecog.ps <- factor(ovarian$ecog.ps,  -->
<!--                           levels = c("1", "2"),  -->
<!--                           labels = c("good", "bad")) -->

<!-- jmv::descriptives(ovarian, varOvarian, freq = TRUE) -->

<!-- ``` -->


<!-- ```{r} -->
<!-- # Data seems to be bimodal -->
<!-- hist(ovarian$age) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- ovarian <- ovarian %>% mutate(age_group = ifelse(age >= 50, "old", "young")) -->
<!-- ovarian$age_group <- factor(ovarian$age_group) -->

<!-- varOvarian <- names(ovarian) -->

<!-- jmv::descriptives(ovarian, varOvarian, freq = TRUE) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- # Fit survival data using the Kaplan-Meier method -->
<!-- surv_object <- Surv(time = ovarian$futime, event = ovarian$fustat) -->
<!-- surv_object -->
<!-- ``` -->

<!-- ```{r} -->
<!-- fit1 <- survfit(surv_object ~ rx, data = ovarian) -->
<!-- summary(fit1) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- ggsurvplot(fit1, data = ovarian, pval = TRUE) -->
<!-- ``` -->


<!-- ```{r} -->
<!-- # Examine prdictive value of residual disease status -->
<!-- fit2 <- survfit(surv_object ~ resid.ds, data = ovarian) -->
<!-- ggsurvplot(fit2, data = ovarian, pval = TRUE) -->
<!-- ``` -->

<!-- ```{r} -->
<!-- # Fit a Cox proportional hazards model -->
<!-- fit.coxph <- coxph(surv_object ~ rx + resid.ds + age_group + ecog.ps,  -->
<!--                    data = ovarian) -->
<!-- ggforest(fit.coxph, data = ovarian) + -->
<!--     geom_errorbar(na.rm = TRUE) -->
<!-- ``` -->



# OpenIntro Statistics 

https://www.openintro.org/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R&referrer=/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R_code&referrer=/stat/surv.php

https://www.openintro.org/download.php?file=survival_analysis_in_R_code_df-cp&referrer=/stat/surv.php


```{r}
# install.packages("OIsurv")
```


```{r}
# library(OIsurv)
library(survival)
library(splines)
library(KMsurv)
```


```{r}
library(help=KMsurv)
```


```{r}
data(aids)
aids
```

```{r}
 data(tongue)
tongue
```


```{r}
my.surv.object <- Surv(tongue$time[tongue$type==1], tongue$delta[tongue$type==1])
my.surv.object
```


```{r}
data(psych)
psych
my.surv.object <- Surv(psych$age, psych$age + psych$time, psych$death)
my.surv.object

```








```{r}
rm(list=ls())

#===> loading packages and such <===#
#install.packages("OIsurv")
library(OIsurv)
data(aids)
aids
attach(aids)
infect
detach(aids)
aids$infect

#===> survival object <===#
data(tongue); attach(tongue)   # the following will not affect computations
# create a subset for just the first group by using [type==1]
my.surv.object <- Surv(time[type==1], delta[type==1])
my.surv.object
detach(tongue)

data(psych); attach(psych)
my.surv.object <- Surv(age, age+time, death)
my.surv.object
detach(psych)

#===> K-M Estimate <===#
data(tongue); attach(tongue)
my.surv <- Surv(time[type==1], delta[type==1])
survfit(my.surv ~ 1)
my.fit <- survfit(my.surv ~ 1)
summary(my.fit)$surv     # returns the Kaplan-Meier estimate at each t_i
summary(my.fit)$time     # {t_i}
summary(my.fit)$n.risk   # {Y_i}
summary(my.fit)$n.event  # {d_i}
summary(my.fit)$std.err  # standard error of the K-M estimate at {t_i}
summary(my.fit)$lower    # lower pointwise estimates (alternatively, $upper)
str(my.fit)              # full summary of the my.fit object
str(summary(my.fit))     # full summary of the my.fit object
pdf("../figures/kmPlot.pdf", 7, 4.5)
plot(my.fit, main="Kaplan-Meier estimate with 95% confidence bounds",
   xlab="time", ylab="survival function")
dev.off()
my.fit1 <- survfit( Surv(time, delta) ~ type )   # here the key is "type"
detach(tongue)

#===> confidence bands <===#
data(bmt); attach(bmt)
my.surv <- Surv(t2[group==1], d3[group==1])
my.cb <- confBands(my.surv, confLevel=0.95, type="hall")
pdf("../figures/confBand.pdf", 8, 5)
plot(survfit(my.surv ~ 1), xlim=c(100, 600), xlab="time",
  ylab="Estimated Survival Function",
  main="Reproducing Confidence Bands for Example 4.2 in Klein/Moeschberger")

lines(my.cb$time, my.cb$lower, lty=3, type="s")
lines(my.cb$time, my.cb$upper, lty=3, type="s")
legend(100, 0.3, legend=c("K-M survival estimate",
  "pointwise intervals","confidence bands"), lty=1:3)
dev.off()
detach(bmt)


#===> cumulative hazard <===#
data(tongue); attach(tongue)
my.surv <- Surv(time[type==1], delta[type==1])
my.fit  <- summary(survfit(my.surv ~ 1))
H.hat   <- -log(my.fit$surv)
H.hat   <- c(H.hat, tail(H.hat, 1))
h.sort.of <- my.fit$n.event / my.fit$n.risk
H.tilde   <- cumsum(h.sort.of)
H.tilde   <- c(H.tilde, tail(H.tilde, 1))
pdf("../figures/cumHazard.pdf", 6, 4)
plot(c(my.fit$time, 250), H.hat, xlab="time", ylab="cumulative hazard",
  main="comparing cumulative hazards", ylim=range(c(H.hat, H.tilde)), type="s")
points(c(my.fit$time, 250), H.tilde, lty=2, type="s")
legend("topleft", legend=c("H.hat","H.tilde"), lty=1:2)
dev.off()
detach(tongue)


#===> mean/median <===#
data(drug6mp); attach(drug6mp)
my.surv <- Surv(t1, rep(1, 21))   # all placebo patients observed
survfit(my.surv ~ 1)
print(survfit(my.surv ~ 1), print.rmean=TRUE)
detach(drug6mp)

#===> test for 2+ samples <===#
data(btrial); attach(btrial)
survdiff(Surv(time, death) ~ im)   # output omitted
survdiff(Surv(time, death) ~ im, rho=1)   # output omitted
detach(btrial)

#===> coxph, time-independent <===#
data(burn); attach(burn)
my.surv   <- Surv(T1, D1)
coxph.fit <- coxph(my.surv ~ Z1 + as.factor(Z11), method="breslow")
coxph.fit
co <- coxph.fit$coefficients  # may use coxph.fit$coeff instead
va <- coxph.fit$var           # I^(-1), estimated cov matrix of the estimates
ll <- coxph.fit$loglik        # log-likelihood for alt and null MLEs, resp.
my.survfit.object <- survfit(coxph.fit)
hold <- survfit(my.surv ~ 1)
#source("http://www.stat.ucla.edu/~david/teac/surv/local-coxph-test.R")
coxph.fit
C   <- matrix(c(0, 1, 0, 0,
                0, 0, 1, 0,
                0, 0, 0, 1), nrow=3, byrow=TRUE)
d   <- rep(0, 3)
t1  <- C %*% co - d
t2  <- C %*% va %*% t(C)
XW2 <- c(t(t1) %*% solve(t2) %*% t1)
pchisq(XW2, 3, lower.tail=FALSE)
#local.coxph.test(coxph.fit, 2:4)
my.survfit.object <- survfit(coxph.fit)
detach(burn)


#===> coxph, time-dependent <===#
data(relapse)
relapse

N  <- dim(relapse)[1]
t1 <- rep(0, N+sum(!is.na(relapse$int)))  # initialize start time at 0
t2 <- rep(-1, length(t1))                 # build vector for end times
d  <- rep(-1, length(t1))                 # whether event was censored
g  <- rep(-1, length(t1))                 # gender covariate
i  <- rep(FALSE, length(t1))              # initialize intervention at FALSE

j  <- 1
for(ii in 1:dim(relapse)[1]){
  if(is.na(relapse$int[ii])){      # no intervention, copy survival record
    t2[j] <- relapse$event[ii]
    d[j]  <- relapse$delta[ii]
    g[j]  <- relapse$gender[ii]
    j <- j+1
  } else {                         # intervention, split records
    g[j+0:1] <- relapse$gender[ii] # gender is same for each time
    d[j]     <- 0                  # no relapse observed pre-intervention
    d[j+1]   <- relapse$delta[ii]  # relapse occur post-intervention?
    i[j+1]   <- TRUE               # intervention covariate, post-intervention
    t2[j]    <- relapse$int[ii]-1  # end of pre-intervention
    t1[j+1]  <- relapse$int[ii]-1  # start of post-intervention
    t2[j+1]  <- relapse$event[ii]  # end of post-intervention
    j <- j+2                       # two records added
  }
}

mySurv <- Surv(t1, t2, d)        # pg 3 discusses left-trunc. right-cens. data
myCPH  <- coxph(mySurv ~ g + i)

#data(burn); attach(burn)
##source("http://www.stat.ucla.edu/~david/teac/surv/time-dep-coxph.R")
#td.coxph <- timeDepCoxph(burn, "T1", "D1", 2:4, "Z1", verbose=FALSE)
#td.coxph   # some model output is omitted for brevity
#detach(burn)

#===> AFT models <===#
data(larynx)
attach(larynx)
srFit <- survreg(Surv(time, delta) ~ as.factor(stage) + age, dist="weibull")
summary(srFit)
srFitExp <- survreg(Surv(time, delta) ~ as.factor(stage) + age, dist="exponential")
summary(srFitExp)
srFitExp$coeff    # covariate coefficients
srFitExp$icoef    # intercept and scale coefficients
srFitExp$var      # variance-covariance matrix
srFitExp$loglik   # log-likelihood
srFit$scale       # not using srFitExp (defaulted to 1)
detach(larynx)

```




```{r}

# Posted with permission of the code author:
# Beau Benjamin Bruce
# Author email: bbbruce@emory.edu
# 
# This code is available under GPL-2
# For license information, see
# http://cran.r-project.org/web/licenses/GPL-2

library(KMsurv)
data(burn)

#=====> Convert a data frame to a counting process version <=====#
#=====> Allows for time dependent variables to be introduced <=====#
df.cp = function(data,t.var,status.var,covars=setdiff(names(data),c(t.var,status.var))) {
  # data: data frame that represents the dataset
  # t.var: the column name of "data" that represents the survival time variable
  # status.var: the column name of "data" that represents the status variable
  # covars: list other covariates to retain
  
  # Returned object: a data frame that breaks each event down to a counting process
  
  # sorted times, append to 0
  t.sort <- c(0,sort(unlist(unique(data[t.var]))))
  
  # for each data point find times less than or equal to the obs' time
  t.list <- lapply(unlist(data[t.var]),function(x) t.sort[t.sort<=x])
  
  # create a list of datasets with covariates and all relevant start/stop times
  # use with to set the environment to the correct list item
  df.list <- lapply(seq_along(t.list),function(i) cbind(with(list(x=t.list[[i]]),
                     # start by removing one from end of x, stop by removing first of x
                     # include the status variable in the dataframe - helpful later                                        
                     data.frame(start=head(x,-1),stop=tail(x,-1),data[i,c(status.var,covars)]))))

  # do.call uses df.list as the argument for rbind
  df <- do.call(rbind,df.list)

  # create the correct status need last time for each
  # subject with status=1 to to be status=1 but all others status=0
  #
  # the lapply creates vectors 0,0,0,...,1 based on length of t.list
  # need to substract 2 because the lag takes one away, then need one for the 1 at end
  # do.call with c binds them together into a single vector
  # this is then multiplied by status to correct it
  keep.status <- do.call(c,lapply(t.list,function(x) c(rep(0,length(x)-2),1)))
  df[status.var] <- df[status.var] * keep.status
  df
}


#=====> Create the counting process data frame <=====#
burn.cp <- df.cp(burn,'T1','D1')
burn.cp <- within(burn.cp,{ T1Z1 <- log(stop)*Z1; }) 

#=====> Apply the Cox Proportional Hazards model <=====#
coxph(Surv(start,stop,D1) ~ Z1+Z2+Z3+T1Z1,data=burn.cp)


```


---

# survsup

- Plotting survival curves with the survsup package  

https://cran.r-project.org/web/packages/survsup/vignettes/survsup_intro.html


http://github.com/dlindholm/survsup/


```{r}
# install.packages("survsup")
```


```{r}
library(survsup)
library(ggplot2)
library(survival)
library(dplyr)
```


```{r}
lung
```



```{r}
fit <- survfit(Surv(time, status) ~ 1, data = lung)
plot_survfit(fit)
```


```{r}
lung %>%
  survfit(Surv(time, status) ~ 1, data = .) %>%
  plot_survfit()
```


```{r}
lung %>%
  survfit(Surv(time, status) ~ 1, data = .) %>%
  plot_survfit(cuminc = FALSE)
```



```{r}
lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE)
```


```{r}
lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE, ci = TRUE)
```


```{r}
lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE, ci = TRUE) + # <--- NOTE!
  labs(x = "Time (days)", y = "Survival (%)")
```


```{r}
lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE) %>%
  nar()
```



```{r}
lung %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit(cuminc = FALSE) %>%
  nar(size = 3)
```



```{r}
colon
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ rx, data = .) %>%
  plot_survfit() %>%
  nar() +
  scale_color_manual(values = c("darkorange", "steelblue", "darkred"))
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  skislopes()
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  skislopes(reverse = TRUE)
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  cat4()
```




```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  hcl_rainbow()
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit() %>%
  nar() %>%
  hcl_rainbow(reverse = TRUE)
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(lwd = 2)
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(lwd = 0.5)
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(legend.title = "Extent of disease")
```




```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(ylim = c(0, 100)) %>%
  nar()
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(xmax = 2000) %>%
  nar()
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ extent, data = .) %>%
  plot_survfit(xmax = 2000, xbreaks = c(0, 1000, 2000)) %>%
  nar()
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar()
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(flip = TRUE)
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(size = 5, flip = TRUE)
```



```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(size = 2, flip = TRUE)
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(y_offset = 0.1, flip = TRUE)
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(y_offset = 0.03, flip = TRUE)
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(separator = FALSE)
```


```{r}
colon %>%
  survfit(Surv(time, status) ~ sex, data = .) %>%
  plot_survfit() %>%
  nar(sep_color = "grey90", sep_lwd = 1.5)
```



https://cran.r-project.org/package=gridExtra


```{r}
library(gridExtra)
```
  

```{r}
p <- list(
  p1 = colon %>%
    survfit(Surv(time, status) ~ sex, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar() +
    labs(tag = "A"),

  p2 = colon %>%
    survfit(Surv(time, status) ~ node4, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar() +
    labs(tag = "B")
)

grid.arrange(grobs = p, ncol = 2)
```


```{r}
# Store plots in a list
p <- list(
  p1 = colon %>%
    survfit(Surv(time, status) ~ 1, data = .) %>%
    plot_survfit(ylim = c(0, 100)) +
    labs(tag = "A"),

  p2 = colon %>%
    survfit(Surv(time, status) ~ rx, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "B"),

  p3 = colon %>%
    survfit(Surv(time, status) ~ extent, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "C"),

  p4 = colon %>%
    survfit(Surv(time, status) ~ sex, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "D"),

  p5 = colon %>%
    survfit(Surv(time, status) ~ node4, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "E"),

  p6 = colon %>%
    survfit(Surv(time, status) ~ surg, data = .) %>%
    plot_survfit(ylim = c(0, 100)) %>%
    nar(2, separator = FALSE) +
    labs(tag = "F")

)

#Define layout matrix
lay <- rbind(c(1,1,2),
             c(1,1,3),
             c(4,5,6))

#Plot it all!
grid.arrange(grobs = p, layout_matrix = lay)
```


```{r}
p[["p3"]]
```



# survivalAnalysis


## Univariate Survival Analysis


https://cran.r-project.org/web/packages/survivalAnalysis/vignettes/univariate.html























My R Codes For Data Analysis

Survival Analysis

Serdar Balcı, MD, Pathologist

2019-02-14